package com.wei.czz.framework.admin.controller;

import java.io.IOException;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

import com.alibaba.excel.EasyExcel;
import com.wei.czz.common.annotation.Auth;
import com.wei.czz.common.annotation.AuthLogin;
import com.wei.czz.common.annotation.Resubmit;
import com.wei.czz.common.constant.Constant;
import com.wei.czz.common.dto.admin.DeptDto;
import com.wei.czz.common.dto.admin.user.UserPageEnumDto;
import com.wei.czz.common.dto.common.UploadDto;
import com.wei.czz.common.easyexcel.listener.ObjectUploadListener;
import com.wei.czz.common.enums.CommonEnum;
import com.wei.czz.common.enums.ResultEnum;
import com.wei.czz.common.enums.admin.user.RequestChannelEnum;
import com.wei.czz.common.jsr303.group.OrderSearch;
import com.wei.czz.common.jsr303.group.Save;
import com.wei.czz.common.jsr303.group.Update;
import com.wei.czz.common.dto.admin.UserDto;
import com.wei.czz.common.property.BatchProperty;
import com.wei.czz.common.tool.PageDto;
import com.wei.czz.common.tool.Result;
import com.wei.czz.common.utils.ContextUtils;
import com.wei.czz.common.utils.ExcelUtils;
import com.wei.czz.common.utils.RegexUtils;
import com.wei.czz.common.vo.admin.user.UpdatePasswordVo;
import com.wei.czz.common.vo.admin.deptUser.DeptUserFormVo;
import com.wei.czz.common.vo.admin.user.UserUploadVo;
import com.wei.czz.common.vo.admin.user.UserFormVo;
import com.wei.czz.common.vo.admin.user.UserVo;
import com.wei.czz.framework.admin.entity.UserEntity;
import com.wei.czz.framework.admin.helper.UserHelper;
import com.wei.czz.framework.admin.manager.DeptManager;
import com.wei.czz.framework.admin.manager.UserManager;
import com.wei.czz.framework.admin.service.UserService;
import com.wei.czz.framework.common.service.AsyncService;
import lombok.AllArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;

/**
 * Created by IntelliJ IDEA.
 *
 * @author wei
 * date: 2021-03-15 10:30:44
 * className: MenuController 用户操作请求接口类
 * version: 1.0
 * description:
 */
@RestController
@RequestMapping("sys/user")
@AllArgsConstructor
public class UserController {

    private static final Logger log = LoggerFactory.getLogger(UserController.class);

    private final BatchProperty batchProperty;

    private final UserService userService;

    private final UserManager userManager;

    private final DeptManager deptManager;

    private final AsyncService asyncService;

    private final UserHelper userHelper;

    /**
     * 保存用户数据接口
     * <p>
     * 调用方：
     *  1、浏览器-后台管理页面-用户管理页面-用户操作弹出框中调用
     *  2、浏览器-后台管理页面-部门与用户管理页面-用户操作弹出框中调用
     * <p>
     * 此接口会校验是否重复提交
     * @param userVo 用户参数对象
     * @return 不返回数据
     */
    @Resubmit(message = "保存用户")
    @PostMapping("/save")
    @Auth(permit = "system:user:save")
    public Result<Object> saveUser(@Validated(Save.class) @RequestBody UserVo userVo) {
        log.info("开始保存用户数据业务。{}", userVo);
        if (StringUtils.isAllBlank(userVo.getPhone(), userVo.getEmail(), userVo.getLoginName())) {
            log.info("用户手机号、邮箱号、登录别名不能同时为空");
            return Result.clientFail("手机号、邮箱号、登录别名不能同时为空");
        }

        // 手机号正则校验
        if (StringUtils.isNotEmpty(userVo.getPhone()) && !RegexUtils.isPhone(userVo.getPhone())) {
            log.info("保存用户数据接口，用户手机号格式错误");
            return Result.getResult(ResultEnum.REQUEST_FAIL.getCode(), "用户手机号格式错误！");
        }
        // 邮箱号正则校验
        if (StringUtils.isNotEmpty(userVo.getEmail()) && !RegexUtils.isEmail(userVo.getEmail())) {
            log.info("保存用户数据接口，用户邮箱号格式错误");
            return Result.getResult(ResultEnum.REQUEST_FAIL.getCode(), "用户邮箱号格式错误！");
        }

        userManager.saveUser(userVo);

        log.info("保存用户数据业务结束");
        return Result.success();
    }

    /**
     * 上传用户接口
     * <p>
     * 调用方：
     *  1、浏览器-后台-用户管理页面-上传抽屉中调用
     * <p>
     * 此接口会校验是否重复提交
     * @param file 文件对象
     * @return 结果
     */
    @Resubmit(spEL = "'uploadUser' + #userId", message = "上传用户")
    @PostMapping("/upload")
    @Auth(permit = "system:user:save")
    public Result<UploadDto<UserUploadVo>> uploadRole(@RequestParam MultipartFile file) {
        log.info("开始上传用户业务。fileName={} fileSize={}", file.getOriginalFilename(), file.getSize());

        ObjectUploadListener<UserUploadVo> objectUploadListener = new ObjectUploadListener<>();
        try {
            // 解析数据
            EasyExcel.read(file.getInputStream(), UserUploadVo.class, objectUploadListener)
                    .sheet()
                    .doRead();
        } catch (IOException e) {
            log.error("用户上传文件解析异常。message={}", e.getMessage(), e);
            return Result.fail();
        }

        if (objectUploadListener.isEmpty()) {
            log.info("用户导入文件内容为空");
            return Result.clientFail("用户导入文件内容不能为空");
        }
        if (batchProperty.getMaxSize() < objectUploadListener.getTotal()) {
            log.warn("用户导入数量超限。batch.maxSize={} list.size={}", batchProperty.getMaxSize(),
                    objectUploadListener.getTotal());
            return Result.clientFail("一次用户角色操作最多允许同时导入" + batchProperty.getMaxSize() + "个角色");
        }

        UploadDto<UserUploadVo> uploadDto = userManager.uploadUser(objectUploadListener);

        log.info("上传角色业务结束");
        return Result.success(uploadDto);
    }

    /**
     * 缓存用户数据接口
     * 根据用户主键列表，将对应的所有用户写入缓存中
     * <p>
     * 调用方
     *  1、浏览器-后台管理页-用户管理页调用
     * <p>
     * 此接口会校验是否重复提交
     * @param userIdList 用户主键列表
     * @return 不返回数据
     */
    @Resubmit(message = "缓存用户")
    @PostMapping("/cache")
    @Auth(permit = "system:user:cache")
    public Result<Object> cacheUser(@RequestBody List<Long> userIdList) {
        log.info("开始缓存用户数据业务。userIdList={}", userIdList);

        if (userIdList.isEmpty()) {
            log.info("缓存用户信息接口，请求参数错误");
            return Result.paramFail();
        }
        if (batchProperty.getMaxSize() < userIdList.size()) {
            log.warn("缓存用户数量超限。batch.maxSize={} list.size={}", batchProperty.getMaxSize(), userIdList.size());
            return Result.clientFail("一次缓存用户操作最多允许同时缓存" + batchProperty.getMaxSize() + "个用户");
        }

        userManager.cacheUser(userIdList);

        log.info("缓存用户数据业务结束");
        return Result.success();
    }

    /**
     * 分页获取用户接口
     * <p>
     * 调用方：
     *  1、浏览器-后台管理页面-用户管理页面调用
     *
     * @param deptUserFormVo 用户查询参数对象
     * @return 用户分页数据
     */
    @PostMapping("/page/list")
    @Auth(permit = "system:dept-user:list")
    public Result<PageDto<UserDto>> getUserPageList(
            @Validated(OrderSearch.class) @RequestBody DeptUserFormVo deptUserFormVo) {
        log.info("开始分页获取用户业务。{}", deptUserFormVo);

        if (StringUtils.isNotBlank(deptUserFormVo.getContact())) {
            /*
                正则判断检索类型用户登录账号
             */
            // 正则判断是否是手机号
            boolean bool = RegexUtils.isPhone(deptUserFormVo.getContact());
            if (!bool) {
                // 正则判断是否是邮箱号
                bool = RegexUtils.isEmail(deptUserFormVo.getContact());
            }
            if (!bool) {
                return Result.clientFail("请输入正确的手机号或者邮箱号进行检索");
            }
        }

        PageDto<UserDto> page = userManager.getUserPageList(deptUserFormVo);

        log.info("分页获取用户业务结束");
        return Result.success(page);
    }

    /**
     * 获取用户管理页面枚举接口
     * <p>
     * 调用方：
     *  1、浏览器-后台管理页面-用户管理页面调用
     * @return 结果
     */
    @GetMapping("/page/param")
    public Result<UserPageEnumDto> getUserPageEnum() {
        log.info("开始获取用户管理页面枚举业务");

        CompletableFuture<DeptDto> future = asyncService.supplyAsync(() -> deptManager.getDeptTree(null));

        UserPageEnumDto userPageEnumDto = userManager.getUserPageEnum();

        try {
            DeptDto deptDto = future.get();
            // 设置
            userPageEnumDto.setDeptTree(deptDto);
        } catch (InterruptedException | ExecutionException e) {
            log.error("异步获取部门结构树异常。message={}", e.getMessage(), e);
            return Result.fail();
        }

        log.info("获取用户管理页面枚举业务结束");
        return Result.success(userPageEnumDto);
    }

    /**
     * 获取用户列表接口
     * <p>
     * 调用方：
     *  1、浏览器-后台管理页-游戏用户管理页-游戏用户添加/修改弹出框调用
     *
     * @return 用户列表
     */
    @GetMapping("/list")
    @Auth(permit = { "game:user:save", "game:user:update" })
    public Result<List<UserDto>> getUserList() {
        log.info("获取用户列表业务");

        List<UserDto> userList = userService.getSimpleUserList();

        return Result.success(userList);
    }

    /**
     * TODO 暂时没有使用的地方
     * 分页查询用户缓存数据列表接口
     * <p>
     * 调用方
     *
     * @param userFormVo 用户缓存查询参数对象
     * @return 接口结果
     */
    @PostMapping("/cache/list")
    @Auth(permit = "cache:user:list")
    public Result<Map<String, Object>> getCacheUserList(
            @Validated(OrderSearch.class) @RequestBody UserFormVo userFormVo) {
        log.info("开始分页查询用户缓存数据列表业务。{}", userFormVo);

        if (userFormVo.getCacheStatus() == null) {
            log.info("分页查询用户缓存数据列表接口请求参数错误");
            return Result.paramFail();
        }

        Map<String, Object> result = userService.getCacheUserList(userFormVo);

        log.info("分页查询用户缓存数据列表业务结束");
        return Result.success(result);
    }

    /**
     * 获取用户数据接口
     * <p>
     * 调用方：
     *  1、浏览器-后台管理页面-用户管理页面中调用
     *
     * @param userId 用户主键
     * @return 用户数据
     */
    @GetMapping("/view")
    @Auth(permit = "system:user:get")
    public Result<UserDto> getUserView(@RequestParam("userId") Long userId) {
        log.info("开始根据系统用户id查询系统用户信息业务。userId={}", userId);

        // 获取用户信息
        UserDto user = userManager.getUserView(userId);

        log.info("根据用户id查询用户信息业务结束");
        return Result.success(user);
    }

    /**
     * 获取用户个人信息接口
     * <p>
     * 调用方：
     *  1、后台管理页面-用户个人信息管理页面调用
     */
    @GetMapping("/info")
    @AuthLogin
    public Result<UserDto> getUserInfo() {
        log.info("开始用户获取个人信息业务");

        UserDto userDto = userManager.getSelf();

        log.info("用户获取个人信息业务结束");
        return Result.success(userDto);
    }

    /**
     * 获取用户权限数据接口
     * <p>
     * 调用方：
     *  1、浏览器-后台管理页面
     *
     * @return 结果
     */
    @GetMapping("/permit")
    @AuthLogin
    public Result<Object> getUserPermit() {
        log.info("开始获取用户权限数据业务");

        Set<String> permitSet = userManager.getPermitSet();

        log.info("获取用户权限数据业务结束");
        return Result.success(permitSet);
    }

    /**
     * TODO 逻辑待调整
     * 获取用户数据接口
     * 根据用户主键获取用户数据
     * <p>
     * 调用方：
     *  1、浏览器-后台管理页面-用户风控管理页面-用户风控操作弹出框中调用
     *
     * @param userId 用户主键
     * @return 用户数据
     */
    @GetMapping("/data")
    @Auth(permit = "user:risk:opt")
    public Result<UserDto> getUser(@RequestParam("userId") Long userId) {
        log.info("开始获取用户数据业务。userId={}", userId);

        UserEntity user = userHelper.get(userId);

        UserDto userDto = new UserDto();
        userDto.setUserId(userId.toString())
                .setUsername(user.getUsername())
                .setAvatar(user.getAvatar())
                .setPhone(user.getPhone())
                .setEmail(user.getEmail())
                .setLoginName(user.getLoginName())
                .setStatus(user.getStatus())
                .setCreateTime(user.getCreateTime());

        log.info("获取用户数据业务结束");
        return Result.success(userDto);
    }

    /**
     * 下载用户导入模板接口
     * @param response 响应对象
     * @return 结果
     */
    @GetMapping("/download/upload-template")
    @Auth(permit = "system:user:save")
    public Result<Object> downloadUploadTemplate(HttpServletResponse response) {
        log.info("开始下载用户导入模板业务");

        List<UserUploadVo> list = new ArrayList<>();

        UserUploadVo userUploadVo = new UserUploadVo();
        userUploadVo.setSerial(CommonEnum.ONE.getValue());
        userUploadVo.setDept("1868562961275793409");
        userUploadVo.setUsername("测试用户1");
        userUploadVo.setPhone("13912341234");
        userUploadVo.setEmail(StringUtils.EMPTY);
        list.add(userUploadVo);

        userUploadVo = new UserUploadVo();
        userUploadVo.setSerial(CommonEnum.TWO.getValue());
        userUploadVo.setDept("测试部门");
        userUploadVo.setUsername("测试用户2");
        userUploadVo.setPhone(StringUtils.EMPTY);
        userUploadVo.setEmail("123456789@qq.com");
        list.add(userUploadVo);

        userUploadVo = new UserUploadVo();
        userUploadVo.setSerial(CommonEnum.TWO.getValue());
        userUploadVo.setDept("测试部门2");
        userUploadVo.setUsername("测试用户3");
        userUploadVo.setPhone(StringUtils.EMPTY);
        userUploadVo.setEmail(StringUtils.EMPTY);
        list.add(userUploadVo);

        ExcelUtils.writeResponse("用户导入模板", list,
                userUploadVo.getTemplatePropertyList(), UserUploadVo.class, response);

        log.info("下载用户导入模板业务结束");
        return null;
    }

    /**
     * TODO 暂时没有使用的地方
     * 获取用户缓存数据接口
     * 根据用户id，获取用户缓存信息
     * <p>
     * 调用方
     *
     * @param userVo 用户请求参数对象
     * @return 请求结果
     */
    @PostMapping("/cache/info")
    @Auth(permit = "cache:user:info")
    public Result<Map<String, Object>> getUserCacheInfo(@RequestBody UserVo userVo) {
        log.info("开始获取用户缓存信息业务。{}", userVo);

        if (Objects.isNull(userVo.getUserId())) {
            log.info("获取用户缓存信息接口请求参数错误");
            return Result.paramFail();
        }

        Map<String, Object> result = userService.getUserCacheInfo(userVo.getUserId());

        log.info("获取用户缓存信息业务结束");
        return Result.success(result);
    }

    /**
     * 用户退出登录接口
     * <p>
     * 调用方：
     *  1、用户管理页面-首页面-头部右侧用户下拉菜单-退出项点击调用
     *  2、浏览器页面-顶部右侧下拉菜单-退出项点击调用
     * @return 结果
     */
    @Resubmit(message = "退出登录")
    @GetMapping("/logout")
    public Result<Object> userLogout() {
        log.info("开始用户退出登录业务");

        // 从上下文参数中获取请求渠道
        String channel = ContextUtils.get(Constant.REQUEST_CHANNEL);
        RequestChannelEnum requestChannelEnum = RequestChannelEnum.get(channel);
        if (Objects.isNull(requestChannelEnum)) {
            log.info("请求渠道不存在");
            return Result.paramFail();
        }

        userManager.userLogout(requestChannelEnum);

        log.info("用户退出登录业务结束");
        return Result.success();
    }

    /**
     * 修改用户数据接口
     * <p>
     * 调用方：
     *  1、浏览器-后台管理页面-用户管理页面-用户操作弹出框中调用
     * <p>
     * 此接口会校验是否重复提交
     * @param userVo 用户参数对象
     */
    @Resubmit(message = "修改用户")
    @PostMapping("/update")
    @Auth(permit = "system:user:update")
    public Result<Object> updateSysUser(@Validated(Update.class) @RequestBody UserVo userVo) {
        log.info("开始系统用户修改业务。{}", userVo);

//        if (userVo.isUpdateParamsFail()) {
//            log.info("修改系统用户信息接口请求参数错误");
//            return Result.paramFail();
//        }
        if (StringUtils.isAllBlank(userVo.getPhone(), userVo.getEmail(), userVo.getLoginName())) {
            log.info("修改用户，手机号、邮箱号、登录别名不能同时为空");
            return Result.clientFail("手机号、邮箱号、登录别名不能同时为空");
        }

        // 手机号正则校验
        if (StringUtils.isNotBlank(userVo.getPhone()) && !RegexUtils.isPhone(userVo.getPhone())) {
            log.info("修改系统用户信息接口，用户手机号格式错误");
            return Result.getResult(ResultEnum.REQUEST_FAIL.getCode(), "用户手机号格式错误！");
        }
        // 邮箱号正则校验
        if (StringUtils.isNotBlank(userVo.getEmail()) && !RegexUtils.isEmail(userVo.getEmail())) {
            log.info("修改系统用户信息接口，用户邮箱号格式错误");
            return Result.getResult(ResultEnum.REQUEST_FAIL.getCode(), "用户邮箱号格式错误！");
        }

        userManager.updateUser(userVo);

        log.info("系统用户修改业务结束");
        return Result.success();
    }

    /**
     * 用户个人信息修改接口
     * <p>
     * 调用方：
     *  1、浏览器-后台管理页面-用户个人信息管理页面调用
     * <p>
     * 此接口会校验是否重复提交
     * @param userVo 封装用户个人信息的对象
     */
    @Resubmit(message = "修改个人信息")
    @PostMapping("/info/update")
    @AuthLogin
    public Result<Object> userInfoUpdate(@Validated(Update.class) @RequestBody UserVo userVo) {
        log.info("开始用户个人信息修改业务。{}", userVo);

//        if (userVo.isInfoUpdateParamsFail()) {
//            log.info("用户个人信息修改接口请求参数错误");
//            return Result.paramFail();
//        }
        if (StringUtils.isAllBlank(userVo.getPhone(), userVo.getEmail(), userVo.getLoginName())) {
            log.info("修改自己，手机号、邮箱号、登录别名不能同时为空");
            return Result.clientFail("手机号、邮箱号、登录别名不能同时为空");
        }
        // 手机号正则校验
        if (StringUtils.isNotBlank(userVo.getPhone()) && !RegexUtils.isPhone(userVo.getPhone())) {
            log.info("用户个人信息修改接口，手机号格式错误");
            return Result.getResult(ResultEnum.REQUEST_FAIL.getCode(), "手机号格式错误！");
        }
        // 邮箱号正则校验
        if (StringUtils.isNotBlank(userVo.getPhone()) && !RegexUtils.isEmail(userVo.getEmail())) {
            log.info("用户个人信息修改接口，邮箱号格式错误");
            return Result.getResult(ResultEnum.REQUEST_FAIL.getCode(), "邮箱号格式错误！");
        }

        userManager.updateMySelf(userVo);

        log.info("用户个人信息修改业务结束");
        return Result.success();
    }

    /**
     * 用户密码修改接口
     * <p>
     * 调用方：
     *  1、浏览器-后台管理页面-用户个人信息管理页面调用
     * <p>
     * 此接口会校验是否重复提交
     * @param updatePasswordVo 参数对象
     * @return 不返回数据
     */
    @Resubmit(message = "修改密码")
    @PostMapping("/pwd/update")
    @AuthLogin
    public Result<Object> userPwdUpdate(@Validated @RequestBody UpdatePasswordVo updatePasswordVo) {
        log.info("开始用户登录密码修改业务。 {}", updatePasswordVo);

        userManager.userPwdUpdate(updatePasswordVo);

        log.info("用户登录密码修改业务结束");
        return Result.success();
    }

    /**
     * 用户密码重置接口
     * <p>
     * 调用方：
     *  1、浏览器-后台管理页面-用户管理页面调用
     * <p>
     * 此接口会校验是否重复提交
     * @param updatePasswordVo 参数对象
     * @return 不返回数据
     */
    @Resubmit(message = "密码重置")
    @PostMapping("/password/reset")
    @Auth(permit = "password:reset")
    public Result<Object> passwordReset(@Validated(Update.class) @RequestBody UpdatePasswordVo updatePasswordVo) {
        log.info("开始用户密码重置业务。{}", updatePasswordVo);

        userManager.userPasswordReset(updatePasswordVo);

        log.info("用户密码重置业务结束");
        return Result.success();
    }

    /**
     * 删除用户数据接口
     * 根据用户主键列表，删除对应的用户数据和用户缓存
     * <p>
     * 调用方：
     *  1、浏览器-后台管理页面-用户管理页面调用
     * <p>
     * 此接口会校验是否重复提交
     * @param userIdList 用户主键列表
     */
    @Resubmit(message = "删除用户")
    @DeleteMapping("/delete")
    @Auth(permit = { "system:user:delete", "system:dept-user:delete" })
    public Result<Object> deleteUser(@RequestBody List<Long> userIdList) {
        log.info("开始删除用户数据业务。userIdList={}", userIdList);

        if (userIdList.isEmpty()) {
            log.info("删除用户数据接口请求参数错误");
            return Result.paramFail();
        }
        if (batchProperty.getMaxSize() < userIdList.size()) {
            log.warn("删除用户数量超限。batch.maxSize={} list.size={}", batchProperty.getMaxSize(), userIdList.size());
            return Result.clientFail("一次删除用户最多允许同时删除" + userIdList.size() + "个用户");
        }

        userManager.deleteUser(userIdList);

        log.info("删除用户数据业务结束");
        return Result.success();
    }

    /**
     * 用户注销接口
     * 用户自己注销自己
     * <p>
     * 调用方：
     *  1、浏览器-后台管理页面-个人中心调用
     */
    @Resubmit(message = "注销")
    @DeleteMapping("/delete/self")
    @Auth(permit = "user:info:update")
    public Result<Object> deleteSelf() {
        log.info("开始用户注销业务");

        userManager.deleteSelf();

        log.info("用户注销业务结束");
        return Result.success();
    }

    /**
     * 删除用户缓存数据接口
     * 根据用户主键列表，删除对应用户的缓存数据
     * <p>
     * 调用方
     *  1、浏览器-后台管理页-用户管理页调用
     * <p>
     * 此接口会校验是否重复提交
     * @param userIdList 用户主键列表
     * @return 请求结果
     */
    @Resubmit(message = "删除用户缓存")
    @DeleteMapping("/cache/delete")
    @Auth(permit = "system:user:cache")
    public Result<Object> deleteUserCache(@RequestBody List<String> userIdList) {
        log.info("开始删除用户缓存信息业务。userIdList={}", userIdList);

        if (userIdList.isEmpty()) {
            log.info("删除用户缓存信息接口请求参数错误");
            return Result.paramFail();
        }
        if (batchProperty.getMaxSize() < userIdList.size()) {
            log.info("删除用户缓存数量超限");
            return Result.clientFail("一次删除用户缓存最多允许同时删除" + userIdList.size() + "个用户");
        }

        userManager.deleteUserOnCache(userIdList);

        log.info("删除用户缓存信息业务结束");
        return Result.success();
    }

    /**
     * 清空用户缓存信息接口
     * 根据用户类型，删除对应用户的缓存信息
     * <p>
     * 调用方
     *  1、浏览器-后台管理页-用户管理页调用
     * <p>
     * 此接口会校验是否重复提交
     * @return 请求结果
     */
    @Resubmit(message = "清空用户缓存")
    @DeleteMapping("/cache/clear")
    @Auth(permit = "system:user:cache")
    public Result<Object> clearUserOnCache() {
        log.info("开始清空用户缓存信息业务");

        userManager.clearUserCache();

        log.info("清空用户缓存信息业务结束");
        return Result.success();
    }

}
